{***************************************************************
    SpyGestion  Copyright (C) 2008 Christophe KOALI <nature2gas@gmail.com>
    
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
    
****************************************************************}
unit L40_modPowerClasses;

interface

uses
     modBaseType,
     SysUtils,
     Classes,

     modUnitAndDefInfos,
     modGIDtoSTR,

     modGalaxiePlanetes,
     modFlotteVaisseauxChoix,


     modClasses,
     L10_modClassesAlerteAtt,
     L20_modClassesConstruction,
     L30_modClassesWithDB,
     L35_modEvacuationAuto,


     modStatsPlayers,

     modRapport,
     modPlanete,

     modListeAttaqueCollection,
     modListeAttaqueVaisseauxInfos,
     modMessagesList;




type

    TPowerPlayer = class(TPlayerWithEvacuationAuto)
    private
        // Géré par la classe
        // Ce n'est pas une simple copie de pointeur
        FListeDattaque: TCollectionListeAction;

        // Nombre de slot libre à laisser
        // Devrait être au moins à 1
        FNbFreeSlotALaisse: integer;


        // Gestion des sondages automatique de vérification
        // On a deux cas:
        // - Vérification avant de lancer l'attaque (pour la liste d'attente d'attaque)
        // - Vérification avant impact
        // on utilise donc deux listes de pointeurs
        //
        // Pour le premier cas:
        // La liste contient des pointeurs de type PLAItem (une simple
        // copie de pointeur à partir de FListeDattaque)

        FListWaitingRapportEspForAttacking       : TList;
        FListWaitingRapportEspForVerifAvantImpact: TList;





        // date de prochain slot de libre
        // ou
        // date pour laquelle il faut refaire la vérification de slot
        // dans le but ne pas trop télécharger la page flotte1
        // Par slot de libre, on prend en compte la valeur FNbFreeSlotALaisse
        FFreeSlotForAttack: int64;


        // pour éviter de télécharge la page des messages trop souvent
        // on définit une date à partir de laquelle on peut à nouveau télécharger
        // cette page
        FMsgListeDateCanDL: int64;


        // pour éviter de traiter les vieux rapport d'espionnage lorsque l'on doit
        // lire les messages, on fixe une date limite
        // tous les messages plus ancien que cette date seront ignorés
        // cette date correspond à la date du SERVEUR (pas locale)
        FMsgListeVieuxMsgDate: int64;



        procedure DoDebugLA(const Msg: string);



        procedure MakeGestionDesRapportEspionnageIfNeed;


        procedure CheckRapportEspionnageInWaitingList(lMsg: TCollectionOGMessage);
        procedure CheckRapportEspionnageInWaitingListFromRapport(Rapport: PRapportHead; pMsg: POGMessage);


        function AttaqueListeProceedLaunch(cAL: PLAItem): integer;


        procedure ClearOwn(bDelFichierSave: boolean);



    public

        // définit si la liste d'attente doit être prise en compte
        ListeDattaqueActive: boolean;



        
        property NbFreeSlotALaisse : integer read FNbFreeSlotALaisse write FNbFreeSlotALaisse;

        function MakeActionIfSlotLibre: integer;


        function RetreiveFlotte1Page(bSansParsing: boolean = false): integer; override;


        //function ProceedEvacuationWithReturnAfterImpact(Cible: TPlanetLocation; iSpeedRatio: integer; bWhere: TOGDestinationType; xOrdre: TOGOrdre): TFlotteEnvoiRes;


        property cListeDattaque: TCollectionListeAction read FListeDattaque;


        




        procedure OnTimer; override;
        procedure Clear(bDelFichierSave: boolean); override;

        constructor Create;
        destructor Destroy; override;

        procedure CreateFakeAttaque;


        // Comme des pointeurs de la liste d'attaque seront présent dans
        // la liste de tracking de flotte (pour le sondage avant impact)
        // il est important de faire le Clear dans la classe et de ne pas
        // appelé le clear de la liste d'attaque directement
        procedure ClearListeDAttaque;

        procedure ShowInternal; override;
    end;

    

implementation

uses modAlarmeAttaque,
     modCore,
     modParsingClass,
     gnugettext,
     sFonctionsChaines,
     modFormulesDuJeu,


     modLanguageParsing,
     Math,
     //WSocket,
     HttpProt,

     ESBDates;


procedure TPowerPlayer.ShowInternal;
begin
        inherited ShowInternal;

        DoDebug('@@@@@ Liste d''attaque @@@@@');


        DoDebugInt('Enable', ListeDattaqueActive);

{$IFNDEF NO_LISTATT}
        DoDebugInt('Allowed', 1);
{$ELSE}
        DoDebugInt('Allowed', 0);
{$ENDIF}

        // Nombre de slot libre à laisser
        // Devrait être au moins à 1
        DoDebugInt('NbFreeSlotALaisser', FNbFreeSlotALaisse);



        // Gestion des sondages automatique de vérification
        // On a deux cas:
        // - Vérification avant de lancer l'attaque (pour la liste d'attente d'attaque)
        // - Vérification avant impact
        // on utilise donc deux listes de pointeurs
        //
        // Pour le premier cas:
        // La liste contient des pointeurs de type PLAItem (une simple
        // copie de pointeur à partir de FListeDattaque)
        DoDebugInt('WEsp'  , FListWaitingRapportEspForAttacking.Count);
        DoDebugInt('WEspAI', FListWaitingRapportEspForVerifAvantImpact.Count);





        // date de prochain slot de libre
        // ou
        // date pour laquelle il faut refaire la vérification de slot
        // dans le but ne pas trop télécharger la page flotte1
        // Par slot de libre, on prend en compte la valeur FNbFreeSlotALaisse
        DoDebugInt('FreeSlotForAttack', FFreeSlotForAttack);


        // pour éviter de télécharge la page des messages trop souvent
        // on définit une date à partir de laquelle on peut à nouveau télécharger
        // cette page
        DoDebugInt('MLDCDL', FMsgListeDateCanDL);


        // pour éviter de traiter les vieux rapport d'espionnage lorsque l'on doit
        // lire les messages, on fixe une date limite
        // tous les messages plus ancien que cette date seront ignorés
        // cette date correspond à la date du SERVEUR (pas locale)
        DoDebugInt('MLVMD', FMsgListeVieuxMsgDate);


end;



procedure TPowerPlayer.ClearListeDAttaque;
begin
    FListeDattaque.FreePointeurAndClear;
end;

procedure TPowerPlayer.CheckRapportEspionnageInWaitingListFromRapport(Rapport: PRapportHead; pMsg: POGMessage);
var i  : integer;
    cAL: PLAItem;
    msgLocalDate: int64;
    iDiff: int64;
    pAttackInfos: PLAActionOrdreAttaquer;
    TotalRessource: integer;
    qtVaisseaux: integer;
begin

{$IFNDEF NO_LISTATT}
    DoDebugLA('CheckREspInWL - Rapport Location: ' + mbtPlanetLocationToStr(Rapport.PlaneteLocation));


    if pMsg.DateEstimation < 500 then begin
       // erreur de l'estimation lors du parsing
       DoDebugLA('CheckREspInWL - Erreur d''estimation de date lors du parsing');
       exit;
    end;

    // on vérifie que c'est un rapport "récent"
    msgLocalDate := pMsg.DateEstimation + DifferenceHeureLocaleHeureServeur;

    iDiff := LastCurrDate - msgLocalDate;

    if iDiff < 0 then begin
       // date future pour pMsg.DateEstimation
       // cela se produit lorsque DifferenceHeureLocaleHeureServeur est mal configuré
       // la différence doit être de quelques secondes en plus dans le futur
       iDiff := iDiff * -1;
    end;

    DoDebugLA('CheckREspInWL - Rapport - Date différence: ' + IntToStr(iDiff));


    if iDiff > 180 then begin
       // trop vieux
       // plus de 3 mins
       DoDebugLA('CheckREspInWL - Rapport - Date trop ancienne, ignoré');

       // le rapport étant "mauvais", on peut quitter dès maintenant
       exit;
    end;


    DoDebugLA('CheckREspInWL - Vérifie si le rapport concerne une action en attente');

    for i := FListWaitingRapportEspForAttacking.Count - 1 downto 0 do begin
       cAL := FListWaitingRapportEspForAttacking.Items[i];

       if CompareLocation(cAL.Operation.Cible, Rapport.PlaneteLocation) then begin
          // ok, c'est le même
          // TODO: pas besoin d'ajustage de lune ?

          DoDebugLA('CheckREspInWL - Location identique Item: ' + IntToStr(i));


          if cAL.ActionOrdreType <> laatAttaquer then begin
             // erreur fatale
             // rien à faire ici
             // l'élément aurait du être enlevé bien avant...
             DoDebugLA('CheckREspInWL - Erreur fatale: Ordre différent d''attaquer');
             FListWaitingRapportEspForAttacking.Delete(i);

             // on peut faire continue car on parcours la liste de haut en bas
             Continue;
          end;


          // on peut supprimer l'élément de la liste
          FListWaitingRapportEspForAttacking.Delete(i);

          pAttackInfos := cAL.ActionOrdre;
          pAttackInfos.Sondage.Status              := lassIdle;
          pAttackInfos.Sondage.NextRapportChecking := 0;
          pAttackInfos.Sondage.FlotteImpactDate := 0;
          pAttackInfos.Sondage.FlotteLaunchDate := 0;
          

          if Rapport.DefenseScore > pAttackInfos.DefenseScoreMax then begin
             // la défense a augmenté
             DoDebugLA(_('CheckREspInWL - La défense de la planète a augmenté, on n''effectue pas l''attaque'));
             Continue;

          end else if Rapport.DefenseScore < pAttackInfos.DefenseScoreMax then begin
             DoDebugLA(_('CheckREspInWL - La défense de la planète a diminué (quelqu''un est certainement passé entre temps)'));

          end else begin
             DoDebugLA(_('CheckREspInWL - Score de défense identique'));

          end;

          TotalRessource := Rapport.Ressource.Metal + Rapport.Ressource.Cristal + Rapport.Ressource.Deuterium;

          if TotalRessource < pAttackInfos.RessourceMin then begin
             // le nombre de ressource a diminué
             DoDebugLA(_('CheckREspInWL - Le nombre de ressource est trop bas, on n''effectue pas l''attaque'));
             Continue;
          end;

          if Rapport.RecyclageNbRessource > pAttackInfos.RecyclageNbRessourceMax then begin
             // le nombre de vaisseaux à augmenter
             DoDebugLA(_('CheckREspInWL - Le nombre de vaisseaux a augmenté, on n''effectue pas l''attaque'));
             Continue;

          end else if Rapport.RecyclageNbRessource < pAttackInfos.RecyclageNbRessourceMax then begin
             DoDebugLA(_('CheckREspInWL - Le nombre de vaisseaux a diminué...'));

          end else begin
             DoDebugLA(_('CheckREspInWL - La flotte à quai semble identique'));

          end;


          
          // Vérifie si on doit recalculer le bon nombre de GT à envoyer
          if pAttackInfos.VaisseauxAjustement.AutoAjustActive then begin
             // on recalcul
             DoDebugLA(_('CheckREspInWL - Réajustement des vaisseaux de transport activé'));

             // calcul la moitié des ressources
             //TotalRessource := TotalRessource shr 1;

             TotalRessource := GetCapaciteDeFret(Rapport.Ressource);


             if pAttackInfos.VaisseauxAjustement.PTVersion then begin
                // version PT
                DoDebugLA(_('CheckREspInWL - Utilisation des PT sélectionnée'));
                qtVaisseaux := Ceil(TotalRessource / 4900);


                if frac(TotalRessource / 4900) > pAttackInfos.VaisseauxAjustement.FractionMajoration then begin
                   Inc(qtVaisseaux);
                end;

                qtVaisseaux := qtVaisseaux + pAttackInfos.VaisseauxAjustement.AjoutSupplementaire;
                if mlaviModifyVaisseaux(@cAL.Vaisseaux, CNT_GID_VAISSEAUX_PETIT_TRANSPORTEUR, qtVaisseaux) then begin
                   DoDebugLA(format(_('CheckREspInWL - OK vaisseaux recalculés, PT: %d'), [qtVaisseaux]));


                end else begin
                   DoDebugLA(format(_('CheckREspInWL - Echec d''affectation, PT: %d'), [qtVaisseaux]));
                   DoDebugLA(_('CheckREspInWL - Abandon'));

                   // l'attaque ne sera jamais effectuée
                   exit;
                end;


             end else begin
                // Version GT
                qtVaisseaux := Ceil(TotalRessource / 24500);
                if frac(TotalRessource / 24500) > pAttackInfos.VaisseauxAjustement.FractionMajoration then begin
                   Inc(qtVaisseaux);
                end;

                qtVaisseaux := qtVaisseaux + pAttackInfos.VaisseauxAjustement.AjoutSupplementaire;
                if mlaviModifyVaisseaux(@cAL.Vaisseaux, CNT_GID_VAISSEAUX_GRAND_TRANSPORTEUR, qtVaisseaux) then begin
                   DoDebugLA(format(_('CheckREspInWL - OK vaisseaux recalculés, GT: %d'), [qtVaisseaux]));

                end else begin
                   DoDebugLA(format(_('CheckREspInWL - Echec d''affectation, GT: %d'), [qtVaisseaux]));
                   DoDebugLA(_('CheckREspInWL - Abandon'));

                   // l'attaque ne sera jamais effectuée
                   exit;
                end;

             end;

          end;


          // on effectue l'attaque
          DoDebugLA(_('CheckREspInWL - Tous semble OK, on effectue l''attaque'));

          // change de planète
          if ChangePlanete(cAL.Depart, true) < 0 then begin
             // echec de changement de planète
             DoDebugLA(_('CheckREspInWL - Echec de changement de planète'));

             // l'attaque ne sera jamais effectuée
             exit;
          end;

          // sélectionne les vaisseaux
          if RetreiveFlotte1Page < 1 then begin
             // echec de récupération de la liste des vaisseaux
             DoDebugLA('CheckREspInWL - Echec de téléchargement de la page flotte');

             // l'attaque ne sera jamais effectuée
             exit;
          end;


          if NoT(mlaviSelectionneVaisseaux(@cAL.Vaisseaux, cFlotteVaisseaux.VaisseauxList)) then begin
             // pas assez de vaisseaux à quai
             // cette vérification a normalement été effectué avant l'envoi des sondes
             // le joueur a t-il déplacé ses vaisseaux entre temps ?? (ou ont-ils été recyclé ou évacué ?)
             DoDebugLA(_('CheckREspInWL - Pas assez de vaisseaux à quai...'));

             // l'attaque doit être reportée
             // si on réinitialise le champ "" alors le robot va réessayer d'attaquer (avec à nouveau
             // envoi de sonde) dans la seconde qui suit
             // il faut que l'on impose un délai avant de réessayer l'élément
             // on fixe donc une date avant laquelle l'élément ne doit plus être pris
             // en compte


             exit;
          end; 


          // les vaisseaux ont été sélectionné, on envoi l'attaque
          DoDebugLA(_('CheckREspInWL - Vaisseaux sélectionnés, on lance l''attaque'));
          
          AttaqueListeProceedLaunch(cAL);


       end;

    end;

{$ENDIF}

end;

procedure TPowerPlayer.CheckRapportEspionnageInWaitingList(lMsg: TCollectionOGMessage);
var peMsg: POGMessage;
    i: integer;
    CurrRapport: TRapportHead;
begin
    if (FListWaitingRapportEspForAttacking.Count = 0) and (FListWaitingRapportEspForVerifAvantImpact.Count = 0) then begin
       exit;
    end;

    DoDebugLA('CheckREInWL - Total Msg: ' + IntToStr(lMsg.Count));

    if lMsg.Count = 0 then begin
       // aucun message
       exit;
    end;
    
    for i := 0 to lMsg.Count - 1 do begin
       peMsg := lMsg.Items[i];


       // au début, FMsgListeVieuxMsgDate est égal à 0
       // donc tous les messages seront lus
       if peMsg.DateEstimation < FMsgListeVieuxMsgDate then begin
          // message trop vieux
          Continue;
       end;


       if (pos(LangParsing.GetData('message_poslw_subject_rapport_esp', 'espion'), lowercase(peMsg.Sujet)) > 0) and (pos('[', peMsg.Sujet) > 0) then begin
          // Probablement un rapport d'espionnage

          CurrRapport := AnalyseRapportEsp(peMsg.Contenu);

          if (CurrRapport.PlaneteLocation.Galaxie > 0) and (CurrRapport.PlaneteLocation.SystemSolaire > 0) then begin
             // rapport valide
             CheckRapportEspionnageInWaitingListFromRapport(@CurrRapport, peMsg);
          end;

       end;


    end;


    // Défini la date à partir de laquelle les messages ont déjà été traité
    // le premier message est le plus récent
    peMsg := lMsg.Items[0];
    FMsgListeVieuxMsgDate := peMsg.DateEstimation;
    
end;


procedure TPowerPlayer.MakeGestionDesRapportEspionnageIfNeed;
var cAL: PLAItem;
    i: integer;
    pAttackInfos: PLAActionOrdreAttaquer;
    bCanDLMsgList: boolean;

    dbMsg: TCollectionOGMessage;
    iDiff: int64;
begin

{$IFNDEF NO_LISTATT}
    if (FListWaitingRapportEspForAttacking.Count = 0) and (FListWaitingRapportEspForVerifAvantImpact.Count = 0) then begin
       exit;
    end;

    LastCurrDate  := DateTimeToUnix(Now);

    if LastCurrDate < FMsgListeDateCanDL then begin
       // on doit attendre un peu  avant d'essayer
       exit;
    end;


    DoDebugLA('MakeGestDREfNeed - Start');


    // sorte de petit vérrou
    // normalement on en a pas besoin car la fonction est exécuté dans OnTimer
    // qui est déjà protégé par un vérrou
    FMsgListeDateCanDL := LastCurrDate + 4;

    
    bCanDLMsgList := false;

    if FListWaitingRapportEspForAttacking.Count > 0 then begin
       for i := 0 to FListWaitingRapportEspForAttacking.Count - 1 do begin
          cAL := FListWaitingRapportEspForAttacking.Items[i];

          if cAL.ActionOrdreType <> laatAttaquer then begin
             // erreur fatale
             // rien à faire ici
             DoDebugLA('MakeGestDREfNeed - Ordre différent d''attaquer');
             FListWaitingRapportEspForAttacking.Delete(i);
             exit;
          end;

          pAttackInfos := cAL.ActionOrdre;

          if pAttackInfos.Sondage.NextRapportChecking <= 100 then begin
             // date invalide...
             // rien à faire ici
             DoDebugLA('MakeGestDREfNeed - Date de prochaine vérification invalide');
             FListWaitingRapportEspForAttacking.Delete(i);
             exit;
          end;


          if pAttackInfos.Sondage.NextRapportChecking <= LastCurrDate then begin
             // on peut télécharger la liste des messages

             // NextRapportChecking est censé être supérieur à FlotteImpactDate
             iDiff := pAttackInfos.Sondage.NextRapportChecking - pAttackInfos.Sondage.FlotteImpactDate;
             if iDiff <= 0 then begin
                // erreur
                DoDebugLA('MakeGestDREfNeed - Date de prochaine vérification invalide (inférieur à l''impact)');
                FListWaitingRapportEspForAttacking.Delete(i);
                exit;
             end;
             if iDiff > 300 then begin
                // on a toujours pas reçu le rapport...
                // pour éviter d'attendre à l'infini le rapport
                // on le supprimer de la liste d'attente
                // peut-être devrions nous réenvoyer les sondes ?
                DoDebugLA('MakeGestDREfNeed - Délai d''attente de rapport dépassé... On ignore cette attaque (iDiff=' + IntToStr(iDiff) + ')');
                FListWaitingRapportEspForAttacking.Delete(i);
                exit;
             end;



             bCanDLMsgList := true;
             pAttackInfos.Sondage.NextRapportChecking := LastCurrDate + 10;

             // Pas de BREAK, car il faut modifier tous les éléments qui ont déclenché
             // le téléchargement de la liste
             // en réalité, il y en a qu'un seul car les éléments ont des "dates"
             // différente qui différente toute d'au moins une seconde
             // Ce qui implique que pour éviter de trop télécharger la liste des messages
             // il faut:
             // - Soit définir une date globale de dernier téléchargement de la liste
             //   et on ne la télécharge plus pendant une certaine durée
             // - Soit on ajuste les date de chaque élément de la liste d'attaque
             //   pour que ça tombe sur un multiple de 10 par exemple
             //break;
          end;

       end;

    end;


    if NoT(bCanDLMsgList) then begin
       if FListWaitingRapportEspForVerifAvantImpact.Count = 0 then begin
          DoDebugLA('MakeGestDREfNeed - Pas autorisé à télécharger la liste des messages');
          exit;
       end;

       // TODO: La vérification de la liste FListWaitingRapportEspForVerifAvantImpact
    end;

    

    if bCanDLMsgList then begin
       // on télécharge la liste des messages
       DoDebugLA('MakeGestDREfNeed - Télécharge la liste des messages...');

       // le fait de placer cette ligne avant, permet de servir
       // de vérrou pour la fonction
       FMsgListeDateCanDL := LastCurrDate + 45;

       dbMsg := TCollectionOGMessage.Create;

       if ProceedGetMessagesList(dbMsg, false, false) < 1 then begin
          DoDebugLA('MakeGestDREfNeed - Erreur de téléchargement de la liste des messages');

       end else begin
          // traite les messages
          CheckRapportEspionnageInWaitingList(dbMsg);
       end;

       // FMsgListeVieuxMsgDate


       // libère la liste
       dbMsg.Free;



    end else begin
       DoDebugLA('MakeGestDREfNeed - Pas autorisé à télécharger la liste des messages');
    end;

{$ENDIF}

end;





function TPowerPlayer.AttaqueListeProceedLaunch(cAL: PLAItem): integer;
label lRessaye, llRetryGest;
var EnvoiRes: TFlotteEnvoiRes;
    NbEssai, i, iRnd: integer;
    pAttackInfos: PLAActionOrdreAttaquer;
    bWasInWaitingREspList: boolean;
begin
     // ici, on lance l'attaque après avoir effectué toutes les vérifications possible
     // les vaisseaux sont DEJA sélectionnés

{$IFNDEF NO_LISTATT}
     NbEssai := 0;

     DoDebugLA('AttaqueListeProceedLaunch - Start');

     pAttackInfos := nil;
     if cAL.ActionOrdreType = laatAttaquer then begin
        pAttackInfos := cAL.ActionOrdre;
     end;

     bWasInWaitingREspList := false;

     // Défini ici que l'élément a été géré
     cAL.DateEffecue := LastCurrDate;


     // Et l'enlève de la liste d'attente de rapport d'espionnage si il y était
     i := FListWaitingRapportEspForAttacking.IndexOf(cAL);
     if NoT(i < 0) then begin
        // il y était
        FListWaitingRapportEspForAttacking.Delete(i);
        bWasInWaitingREspList := true;
     end;


     
     //////////////////////////////////
     // A présent, tout ce joue ici
     // Si cela est nécessaire, on le rajoutera dans la liste d'attente
     // des rapports, et/ou on réinitialisera sa date d'effectue
     //
     // Dans le cas contraire, l'élément est considéré comme "fait"
     

lRessaye:
     Inc(NbEssai);
     EnvoiRes := ProceedEnvoiDeFlotte(@cAL.Operation);




     case EnvoiRes of
        ferFatalError: begin
           // es-ce que l'on tente un autre essai ?
           DoDebugLA('AttaqueListeProceedLaunch - Erreur fatale');
           Result := -1;
           exit;
        end;

        ferSocketError: begin
           // erreur de socket
           // perte de la connexion à internet ?
           DoDebugLA('AttaqueListeProceedLaunch - Erreur de socket - Le serveur lag ??');

           // on réessaye
           goto llRetryGest;
        end;


        ferShouldRetry, ferShouldRetryButNotError: begin
           DoDebugLA('AttaqueListeProceedLaunch - Doit réessayer');
llRetryGest:
           // réessaye...
           if NbEssai = 1 then begin
              DoDebugLA('AttaqueListeProceedLaunch - Réessaye...');
              goto lRessaye;
           end;
           // trop d'essai
           DoDebugLA('AttaqueListeProceedLaunch - Trop d''essai');
           Result := -1;
           exit;
        end;

        ferSuccess: begin
           DoDebugLA(_('AttaqueListeProceedLaunch - Réussi'));

           Randomize;


           iRnd := Random(19);
           iRnd := iRnd + 5;

           DoDebugLA(format(_('AttaqueListeProceedLaunch - Pause de %d secondes'), [iRnd]));

           iRnd := iRnd * 1000;
           DoSleep(iRnd);

           Result := 1;
        end;

        ferNoVaisseaux: begin
           // comme expliqué dans les spécifications, les vaisseaux sont déjà sélectionnés
           // cette erreur ne devrait pas arrivée
           DoDebugLA(_('AttaqueListeProceedLaunch - Pas de vaisseaux'));
           Result := -1;
           exit;
        end;
        ferFlotteMaxAtteinte: begin
           //  la vérification aurait déjà du être faite
           DoDebugLA(_('AttaqueListeProceedLaunch - Max flotte atteint'));
           Result := -1;
           exit;
        end;


        ferNotOrReLoginCertain: begin
           // cela tombe juste sur une déconnexion...
           // on réessayera plus tard...
           // devrions nous désactiver le sondage avant le lancement de l'attaque
           // pour éviter de tout refaire ???
           // Pour l'instant, on considère cela comme une erreur
           DoDebugLA(_('AttaqueListeProceedLaunch - Doit se relogger (certitude)'));
           Result := -1;
           exit;

(*         // on refait tout, y compris le sondage
           cAL.DateCanPrisEnCompte := LastCurrDate + 60;

           if pAttackInfos <> nil then begin
              pAttackInfos.Sondage.NextRapportChecking := cAL.DateCanPrisEnCompte;
           end;
           exit;
           *)
        end;
        
        ferPlaneteInvalid: begin
           // planète invalide
           DoDebugLA(_('AttaqueListeProceedLaunch - Planète invalide (newbz, détruite, vacances)'));
           Result := -1;
           exit;
        end;
     end;

     
     DoDebugLA(_('AttaqueListeProceedLaunch - Télécharge la page flotte1 pour "suivre" la flotte'));

     
       // si on arrive ici, c'est que l'envoi de l'attaque à réussi
       // obtient le slot de flotte dans la liste
       if RetreiveFlotte1Page < 1 then begin
          // erreur...
          DoDebugLA(_('AttaqueListeProceedLaunch - Erreur de téléchargement de la page flotte1 pour vérifier l''existance de la flotte attaquante'));
          exit;
       end;

       if FlotteTracking.LastFlotteAdded = nil then begin
          // erreur de tracking
          DoDebugLA(_('AttaqueListeProceedLaunch - Erreur de tracking (nil)'));
          exit;
       end;


       if CompareLocationMoonAutoAjust(FlotteTracking.LastFlotteAdded.Depart, cAL.Depart) then begin
          // ok, on compare l'arrivé maintenant
          if CompareLocationMoonAutoAjust(FlotteTracking.LastFlotteAdded.Arrivee, cAL.Operation.Cible) then begin
             // c'est bien cela
             DoDebugLA(_('AttaqueListeProceedLaunch - Tracking ok'));


             // TODO: Programmer ici le sondage avant impact



          end else begin
             DoDebugLA(_('AttaqueListeProceedLaunch - Erreur de tracking - Planète d''arrivée différente'));
          end;


       end else begin
          DoDebugLA(_('AttaqueListeProceedLaunch - Erreur de tracking - Planète de départ différente'));
       end;

{$ENDIF}

end;


function TPowerPlayer.MakeActionIfSlotLibre: integer;
label lRedo, lJump, lDoFirstTestFlotte1;
var cAL, cALx: PLAItem;
    iDiff: int64;
  
    iSlotLibre: integer;
    pAttackInfos: PLAActionOrdreAttaquer;

    EnvoiRes: TFlotteEnvoiRes;
    iRedo: integer;

begin

{$IFNDEF NO_LISTATT}
    if FListeDattaque.Count = 0 then begin
       // Liste vide, rien à faire
       Result := 1;
       exit;
    end;

    // extrait le prochain élément
    cAL := FListeDattaque.GetNextItemToDo;
    if cAL = nil then begin
       // plus d'élément
       Result := 1;
       exit;
    end;

    


    LastCurrDate := DateTimeToUnix(Now);



    

    // avant de vérifier si il y a un slot de libre, on vérifie si l'élément
    // peut être utilisé
    if cAL.DateCanPrisEnCompte > 500 then begin
       // il existe une limite
       // l'élément a du déjà être traité, mais une erreur a du être rencontré
       // (du genre pas de vaisseaux à quai, ou rapport d'espionnage trop long à vennir)
       if cAL.DateCanPrisEnCompte <= LastCurrDate then begin
          // on a atteint la date, on peut traiter  à nouveau l'élément

       end else begin
          // sinon l'élément doit être ignoré pour le moment
          Result := 1;
          exit;
       end;
    end;
    

    
    Result := 0;

    // Es-ce que l'on connait la date du prochain slot de libre ?
    if FFreeSlotForAttack > 200 then begin
       // on connait la date d'un retour de flotte, ou d'impact

       // es ce que l'on a dépssé cette date ?
       if FFreeSlotForAttack <= LastCurrDate  then begin
          // oui, on a atteint cette date
          // on vérifie qu'effectivement il y a un slot de libre

lDoFirstTestFlotte1:
          if RetreiveFlotte1Page < 1 then begin
             // erreur...
             DoDebugLA('Erreur de téléchargement de la page flotte1');
             exit;
          end;
          
          iSlotLibre := MaxSlot - cFlotteVaisseaux.FlotteUsed;
          if iSlotLibre <= 0 then begin
             // pas de slot de libre
             exit;
          end;
          if iSlotLibre <= FNbFreeSlotALaisse then begin
             // on doit laisser les slots libre
             exit;
          end;

          // Nombre de slot utilisable parmis les slots libres
          iSlotLibre := iSlotLibre - FNbFreeSlotALaisse;
          
          // sinon c'est ok, il y a un slot de libre
          // MAIS, il se peut qu'il va être utilisé prochainement par un élément
          // en attente de rapport
          // normalement ce n'est pas le cas car la sonde doit occupé un slot
          // mais on ne lit pas directement le rapport d'espionnage dès l'impact
          // donc on est obligé de vérifier le nombre d'élément en attente
          if FListWaitingRapportEspForAttacking.Count > 0 then begin
             // il y a des éléments en attente

             if iSlotLibre > FListWaitingRapportEspForAttacking.Count then begin
                // pas de problème, on peut lancer l'atttaque

             end else begin
                // on doit attendre un peu
                
                cALx := FListWaitingRapportEspForAttacking.Items[0];

                if cALx.ActionOrdreType = laatAttaquer then begin
                   pAttackInfos := cALx.ActionOrdre;


                   Randomize;
                   FFreeSlotForAttack := pAttackInfos.Sondage.NextRapportChecking + 10 + Random(30);

                   if FFreeSlotForAttack < LastCurrDate + 10 then begin
                      FFreeSlotForAttack := LastCurrDate + 20 + Random(30);
                   end;
                   
                end else begin
                   // si l'ordre n'est pas laatAttaquer, il n'y a aucun intéret à ce
                   // qu'il figure dans FListWaitingRapportEspForAttacking
                   DoDebugLA('MakeActionIfSlotLibre - Erreur de présence');
                   FFreeSlotForAttack := LastCurrDate + 20;
                end;

                DoDebugLA('MakeActionIfSlotLibre - Prochaine vérification de slot libre: ' + DateTimeToStr(UnixToDateTime(FFreeSlotForAttack)) + ' (ext)' + format(_(' (MaxSlot: %d, Utilisé: %d, Contrainte: %d)'), [MaxSlot, cFlotteVaisseaux.FlotteUsed, FNbFreeSlotALaisse]));

                exit;
             end;

          end;


       end else begin
          // on n'a pas encore dépassé la date
          exit;
       end;

    end else begin
       // la date du prochain slot de libre est inconnu...
       // on est alors obligé de télécharger la page flotte1
       goto lDoFirstTestFlotte1;
    end;


    DoDebugLA(_('MakeActionIfSlotLibre -> Slot libre OK'));

    // si on arrive c'est que:
    // -> La page de flotte1 a été téléchargé
    // -> Il existe un slot pouvant être utilisé par le robot pour attaquer
    
    // Cependant, la page flotte1 n'est pas forcément celle de la planète à partir
    // de laquelle on va attaquer
    


    if cAL.ActionOrdreType = laatAttaquer then begin
       // Vérifie si l'on doit sonder avant d'envoyer la flotte
       // le pointeur est donc de type PLAActionOrdreAttaquer
       pAttackInfos := cAL.ActionOrdre;


       // avant de vérifier si l'on doit sonder (et sondé)
       // on vérifie si il y a assez de vaisseaux sur la planète de départ

       // force le changement de planète
       if ChangePlanete(cAL.Depart, true) < 0 then begin
          // erreur de changement de planète
          DoDebugLA(_('MakeActionIfSlotLibre - Erreur de changement de planète pour vérifier si il y a des vaisseaux à quai'));
          cAL.DateCanPrisEnCompte := LastCurrDate + 30;
          exit;
       end;
       
       // télécharge la page flotte1 de cette planète
       if RetreiveFlotte1Page < 1 then begin
          // erreur...
          DoDebugLA(_('MakeActionIfSlotLibre - Erreur de téléchargement de la page flotte1 pour vérifier si il y a des vaisseaux à quai'));
          cAL.DateCanPrisEnCompte := LastCurrDate + 45;
          exit;
       end;


       // vérifie qu'il y a assez de vaisseaux pour lancer l'attaque
       if NoT(mlaviSelectionneVaisseaux(@cAL.Vaisseaux, cFlotteVaisseaux.VaisseauxList)) then begin
          // pas assez de vaisseaux
          DoDebugLA(_('MakeActionIfSlotLibre - Pas assez de vaisseaux à quai'));
          cFlotteVaisseaux.VaisseauxList.DeSelectionneTousLesVaisseaux;
          cAL.DateCanPrisEnCompte := cFlotteVaisseaux.FlotteList.GetDateFirstImpact + DifferenceHeureLocaleHeureServeur;

          if cAL.DateCanPrisEnCompte < (LastCurrDate + 45) then begin
             DoDebugLA(_('MakeActionIfSlotLibre - Extension de la durée'));
             cAL.DateCanPrisEnCompte := LastCurrDate + 45;
          end;
          exit;
       end;

       

       if pAttackInfos.Sondage.DoAvantAttaque > 0 then begin
          // on sonde avant l'envoi de l'attaque
          DoDebugLA(_('MakeActionIfSlotLibre - Sondage avant l''attaque activé... On se prépare à envoyer la (ou les) sondes'));


          // on désélectionne les vaisseaux
          cFlotteVaisseaux.VaisseauxList.DeSelectionneTousLesVaisseaux;

          if pAttackInfos.Sondage.NbSondes < 1 then begin
             // erreur
             DoDebugLA(_('Erreur ->  pAttackInfos.Sondage.NbSondes < 1'));

             // on ne traitera plus l'élément, le marque comme effectué
             cAL.DateEffecue := LastCurrDate;
             exit;
          end;

          
          // force le changement de planète
          if ChangePlanete(pAttackInfos.Sondage.Planete, true) < 0 then begin
             // erreur de changement de planète
             DoDebugLA('MakeActionIfSlotLibre - Erreur en changement de planète qui possède les sondes');

             // on réessaye plus tard...
             cAL.DateCanPrisEnCompte := LastCurrDate + 30;
             exit;
          end;


          // vérifie si il existe des sondes
          if RetreiveFlotte1Page < 1 then begin
             // erreur...
             DoDebugLA('MakeActionIfSlotLibre - Erreur de téléchargement de la page flotte1 de la planète qui possède les sondes');

             // on réessaye plus tard...
             cAL.DateCanPrisEnCompte := LastCurrDate + 30;
             exit;
          end;

          if cFlotteVaisseaux.VaisseauxList.GetNbVaisseauxDispo(CNT_GID_VAISSEAUX_SONDES) < pAttackInfos.Sondage.NbSondes then begin
             // pas assez de sonde sur la planète
             DoDebugLA('MakeActionIfSlotLibre - Erreur -> Pas assez de sondes sur la planète utiliser pour sonder');

             // on ne traitera plus l'élément, le marque comme effectué
             cAL.DateEffecue := LastCurrDate;
             exit;
          end;


          // sélectionne les vaisseaux; nécessaire pour pouvoir calculer la durée du voyage
          cFlotteVaisseaux.VaisseauxList.SetVaisseauxAUtiliser(CNT_GID_VAISSEAUX_SONDES, pAttackInfos.Sondage.NbSondes);
          pAttackInfos.Sondage.DureePourAtteindreLaCible    := mfdgGetDurationTrajet100pSF(cAL.Depart, cAL.Operation.Cible, cFlotteVaisseaux.VaisseauxList.GetSpeedUsed, Conf.UniversSpeedFactorFlotte);
          cFlotteVaisseaux.VaisseauxList.DeSelectionneTousLesVaisseaux;

          DoDebugLA('MakeActionIfSlotLibre - Durée du trajet des sondes vers la cible: ' + IntToStr(pAttackInfos.Sondage.DureePourAtteindreLaCible) + ' secondes');

          iRedo := 0;
lRedo:
          DoDebugLA('MakeActionIfSlotLibre - Effectue le sondage...');
          EnvoiRes := ProceedSondage(cAL.Operation.Cible, pAttackInfos.Sondage.NbSondes);
          Inc(iRedo);

          case EnvoiRes of
             ferFatalError: begin
                DoDebugLA('MakeActionIfSlotLibre Sondage: Erreur -> Fatale');

                // on ne traitera plus l'élément, le marque comme effectué
                cAL.DateEffecue := LastCurrDate;
                exit;
             end;

             ferSocketError: begin
                // ce cas ne devrait plus se produire
                DoDebugLA('MakeActionIfSlotLibre Sondage: Erreur -> Socket erreur (le serveur lag ?)');

                // on ne traitera plus l'élément, le marque comme effectué
                cAL.DateEffecue := LastCurrDate;
                exit;
             end;

             ferShouldRetry, ferShouldRetryButNotError: begin
                 if iRedo <= 1 then begin
                    // ok, encore un essai
                    DoSleep(500);
                    goto lRedo;
                 end;
                 // sinon échec
                DoDebugLA('MakeActionIfSlotLibre Sondage: Erreur -> Trop d''essai d''envoi de sonde');

                // on ne traitera plus l'élément, le marque comme effectué
                cAL.DateEffecue := LastCurrDate;
                exit;
             end;

             ferSuccess: begin
                // réussi
                // fait une pause

             end;

             ferNoVaisseaux: begin
                // impossible que ce cas se produise...
                DoDebugLA('MakeActionIfSlotLibre Sondage: Erreur -> Pas de vaisseaux');
                cAL.DateEffecue := LastCurrDate;
                exit;
             end;
             ferFlotteMaxAtteinte: begin
                // impossible que ce cas se produise...
                DoDebugLA('MakeActionIfSlotLibre Sondage: Erreur -> Max flotte atteint');
                cAL.DateEffecue := LastCurrDate;
                exit;
             end;
             ferNotOrReLoginCertain: begin
                DoDebugLA('MakeActionIfSlotLibre Sondage: Erreur -> Doit se relogger');

                // on réessaye plus tard...
                cAL.DateCanPrisEnCompte := LastCurrDate + 30;
                exit;
             end;


             ferPlaneteInvalid: begin
                DoDebugLA('MakeActionIfSlotLibre Sondage: Erreur -> Planète invalide');
                cAL.DateEffecue := LastCurrDate;
                exit;
             end;
          end;

          
          // si on arrive ici, c'est que l'envoi des sondes a réussi
          // obtient le slot de flotte dans la liste
          if RetreiveFlotte1Page < 1 then begin
             // erreur...
             DoDebugLA('MakeActionIfSlotLibre Sondage: Erreur de téléchargement de la page flotte1 pour vérifier l''existance de la sonde');

             // on ne traitera plus l'élément, le marque comme effectué
             cAL.DateEffecue := LastCurrDate;
             exit;
          end;

          if FlotteTracking.LastFlotteAdded = nil then begin
             // erreur de tracking
             DoDebugLA('MakeActionIfSlotLibre Sondage: Erreur de tracking');
             cAL.DateEffecue := LastCurrDate;
             exit;
          end;


          if CompareLocationMoonAutoAjust(FlotteTracking.LastFlotteAdded.Depart, pAttackInfos.Sondage.Planete) then begin
             // ok, on compare l'arrivé maintenant
             if CompareLocationMoonAutoAjust(FlotteTracking.LastFlotteAdded.Arrivee, cAL.Operation.Cible) then begin
                // c'est bien cela
                // extrait la date d'impact

                DoDebugLA('MakeActionIfSlotLibre - Sondage réussi, on attend le rapport pour lancer l''attaque');

                pAttackInfos.Sondage.FlotteImpactDate := FlotteTracking.LastFlotteAdded.ArriveeDateLocal;
                pAttackInfos.Sondage.FlotteLaunchDate := LastCurrDate;

                pAttackInfos.Sondage.NextRapportChecking := FlotteTracking.LastFlotteAdded.ArriveeDateLocal + 7;


                // et l'ajoute dans la liste d'attente
                pAttackInfos.Sondage.Status := lassAttenteRapport;

                // on place le pointeur dans la liste d'attente de rapport après être
                // certains que la sonde a été envoyé
                FListWaitingRapportEspForAttacking.Add(cAL);


                // L'élément ayant été pris en compte, on le considère comme effectuée
                // sinon, il va être à nouveau renvoyé par GetNextItemToDo
                cAL.DateEffecue := LastCurrDate;

                // extrait le prochain élément
                cAL := FListeDattaque.GetNextItemToDo;
                if cAL <> nil then begin
                   Randomize;
                   cAL.DateCanPrisEnCompte := LastCurrDate + 7 + Random(14);
                end;

             end else begin
                DoDebugLA('MakeActionIfSlotLibre Sondage: Erreur de tracking (cible différente)');
                cAL.DateEffecue := LastCurrDate;
                exit;
             end;

          end else begin
             DoDebugLA('MakeActionIfSlotLibre Sondage: Erreur de tracking (origine différente)');
             cAL.DateEffecue := LastCurrDate;
             exit;
          end;



       end else begin
          // on ne doit pas sondé avant d'attaquer
          // ET
          // les vaisseaux sont déjà sélectionnées
          // on envoi l'attaque

          AttaqueListeProceedLaunch(cAL);
       end;

    end;
{$ENDIF}

end;




function TPowerPlayer.RetreiveFlotte1Page(bSansParsing: boolean = false): integer;
var iFlotteLibre: integer;
    cALx: PLAItem;
    pAttackInfos: PLAActionOrdreAttaquer;
begin

    Result := inherited RetreiveFlotte1Page(bSansParsing);


    if (Result > 0) and (bSansParsing = false) then begin
       // met à jour les flottes

       if ListeDattaqueActive then begin
          // liste d'attaque active

          if (MaxSlot - cFlotteVaisseaux.FlotteUsed) > FNbFreeSlotALaisse then begin
             // il y a un slot de libre pour effectuer une attaque automatique
             FFreeSlotForAttack := FlotteTracking.LastDateUpdated - 1;

             // mais pas forcément car il se peut que l'on attend des rapports d'espionnage
             if FListWaitingRapportEspForAttacking.Count > 0 then begin
                // il y a des éléments en attente
                // calcul le nombre de slot libre utilisable (positif obligatoirement)
                iFlotteLibre := cFlotteVaisseaux.FlotteMax - cFlotteVaisseaux.FlotteUsed - FNbFreeSlotALaisse;

                // soustrait ce nombre au nombre d'attaque qui sont prévu (si les rapports se télécharge bien)
                iFlotteLibre := iFlotteLibre - FListWaitingRapportEspForAttacking.Count;

                if iFlotteLibre > 0 then begin
                   // ok, il reste encore des slots de libre
                   // on ne change pas la date

                end else begin
                   // il n'y a pas obligatoirement de slot de libre...
                   cALx := FListWaitingRapportEspForAttacking.Items[0];

                   if cALx.ActionOrdreType = laatAttaquer then begin
                      pAttackInfos := cALx.ActionOrdre;

                      Randomize;
                      FFreeSlotForAttack := pAttackInfos.Sondage.NextRapportChecking + 10 + Random(30);

                      if FFreeSlotForAttack < LastCurrDate + 10 then begin
                         FFreeSlotForAttack := LastCurrDate + 20 + Random(30);
                      end;

                   end else begin
                      // différent d'attaque, l'élément ne devrait pas être dans la liste
                      DoDebugLA('RetreiveFlotte1Page - Erreur d''ordre dans la liste');
                      FFreeSlotForAttack := LastCurrDate + 50;
                   end;

                   DoDebugLA('RetreiveFlotte1Page - Prochaine vérification de slot libre: ' + DateTimeToStr(UnixToDateTime(FFreeSlotForAttack)) + ' (ext-' + IntToStr(FListWaitingRapportEspForAttacking.Count) + ')');

                end;

             end;

          end else begin
             // sinon, cherche à quelle heure un slot va se libérer
             // OU
             // à quelle heure une flotte fait son impact
             Randomize;
             FFreeSlotForAttack := cFlotteVaisseaux.FlotteList.GetDateFirstImpact + DifferenceHeureLocaleHeureServeur + 10 + Random(45);

             if FFreeSlotForAttack <= FlotteTracking.LastDateUpdated  then begin
                DoDebugLA('RetreiveFlotte1Page - Date situé dans le passé, le serveur de jeu doit lagger...');
                FFreeSlotForAttack := FlotteTracking.LastDateUpdated + 35 + Random(45);
             end;

             DoDebugLA('RetreiveFlotte1Page - Prochaine vérification de slot libre: ' + DateTimeToStr(UnixToDateTime(FFreeSlotForAttack)) + format(_(' (MaxSlot: %d, Utilisé: %d, Contrainte: %d)'), [MaxSlot, cFlotteVaisseaux.FlotteUsed, FNbFreeSlotALaisse]));
          end;

       end else begin
          FFreeSlotForAttack := FlotteTracking.LastDateUpdated - 1;

       end;


    end else begin
       // Erreur de dl... ou bSansParsing = true
       
    end;


    
end;











procedure TPowerPlayer.CreateFakeAttaque;
var peAttack: PAlarmeAttack;
begin

    New(peAttack);

    peAttack.uid.DateImpact := DateTimeToUnix(Now) + 1000;
    peAttack.uid.Location   := 9877;

    peAttack.DateImpactServeur  := peAttack.uid.DateImpact;
    peAttack.DateImpactLocal    := peAttack.DateImpactServeur + 974;


        // Le délai doit être aléatoire, pour éviter d'obtenir un nombre
        // aléatoire à chaque fois (et donc à un moment donné obtenir un petit nombre)
        // on stock ici la valeur du nombre obtenu et on utilise ensuite ce délai
    peAttack.DelaiAvantImpactEva := 2500;
                      
    
    peAttack.Depart.Galaxie       := 4;
    peAttack.Depart.SystemSolaire := 3;
    peAttack.Depart.Position      := 2;

    peAttack.ConnuDepuis := DateTimeToUnix(Now) - 5;
    peAttack.SignalBeepNb  := 0;
    peAttack.SignalMusiqueNb := 0;
    peAttack.ProgramLauched := false;

    peAttack.NbBoucleOverride := 0;
    peAttack.HumainSoccupeDuReste := CNT_ALERTE_ATT_HUMAN_NOT_NOTIFIED;

    peAttack.FlotteExistePlus := false;
    peAttack.FlotteDateCancel := -1;
    peAttack.FlotteExistePlusNotified  := false;

    peAttack.ScoreFlotteAQuai     := -1;
    peAttack.ScoreFlotteAttaquante:= -1;
    peAttack.ScoreDefense         := -1;


    //peAttack.VaisseauxAttaquant   := 'Petit transporteur 2; Grand transporteur 225; Chasseur léger 262; Vaisseau de bataille 66; Recycleur 1';
    peAttack.VaisseauxAttaquant   := 'Vaisseau de bataille 10000';



    peAttack.EvacuationAutomatique := aaeEvacuerEnAttente;


    AlerteAttaqueGestion.SimpleAdd(peAttack);

end;

procedure TPowerPlayer.OnTimer;
begin

    inherited OnTimer;

    if IsLoggedAndCanDoSomething = false then begin
       exit;
    end;


{$IFNDEF NO_LISTATT}
    if ListeDattaqueActive then begin
       MakeActionIfSlotLibre;
       MakeGestionDesRapportEspionnageIfNeed;
    end;
{$ENDIF}


end;

procedure TPowerPlayer.DoDebugLA(const Msg: string);
begin
{$IFDEF DEBUG}
   inherited DoDebug('Liste d''attente - ' + Msg);
{$ENDIF}
end;

procedure TPowerPlayer.ClearOwn(bDelFichierSave: boolean);
begin


    if bDelFichierSave then begin
       // on doit conserver la liste d'attaqe car il se peut qu'on se relog
       // suite à la déconnexion de 03h00
       // la liste de raids ne doit pas être perdu
       FListeDattaque.Clear;


       ListeDattaqueActive := false;



       FMsgListeVieuxMsgDate := 0;
       FMsgListeDateCanDL    := 0;
       FMsgListeVieuxMsgDate := 0;
    end;

end;

procedure TPowerPlayer.Clear(bDelFichierSave: boolean);
begin
    inherited Clear(bDelFichierSave);

    // clear est appelé dans le constructeur
    // et comme on l'a overridé, le clear de la classe mère
    // va appeller le clear de la classe fille, dont l'objet
    // FFlotteTracking n'existe pas encore
    if FListeDattaque <> nil then begin
       ClearOwn(bDelFichierSave);
    end;



end;


constructor TPowerPlayer.Create;
begin
    inherited Create;


        FListeDattaque := TCollectionListeAction.Create;

        FNbFreeSlotALaisse := 1;

        FListWaitingRapportEspForAttacking       := TList.Create;
        FListWaitingRapportEspForVerifAvantImpact:= TList.Create;

        ListeDattaqueActive := false;

        ProcForCapacite := nil;

        ClearOwn(true);

end;


destructor TPowerPlayer.Destroy;
begin

    FListWaitingRapportEspForAttacking.Free;
    FListWaitingRapportEspForVerifAvantImpact.Free;


    FListeDattaque.FreePointeurAndClear;
    FListeDattaque.Free;


    inherited Destroy;
end;

end.
